Glide v3.7源码分析(2)-----RequestManager.load

发表于 | 分类于 | | 阅读数 次
字数统计: 3,145字 | 阅读时长 ≈ 18分钟

代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
private <T> DrawableTypeRequest<T> loadGeneric(Class<T> modelClass) {
        //1. 获取streamModelLoader
        ModelLoader<T, InputStream> streamModelLoader = Glide.buildStreamModelLoader(modelClass, context);
        //2. 获取fileDescriptorModelLoader
        ModelLoader<T, ParcelFileDescriptor> fileDescriptorModelLoader =
                Glide.buildFileDescriptorModelLoader(modelClass, context);
        if (modelClass != null && streamModelLoader == null && fileDescriptorModelLoader == null) {
            throw new IllegalArgumentException("Unknown type " + modelClass + ". You must provide a Model of a type for"
                    + " which there is a registered ModelLoader, if you are using a custom model, you must first call"
                    + " Glide#register with a ModelLoaderFactory for your custom model class");
        }

        //3. 获取DrawableTypeRequest
        return optionsApplier.apply(
                new DrawableTypeRequest<T>(modelClass, streamModelLoader, fileDescriptorModelLoader, context,
                        glide, requestTracker, lifecycle, optionsApplier));
}

public DrawableTypeRequest<String> load(String string) {
        //4. load
        return (DrawableTypeRequest<String>) fromString().load(string);
}

public DrawableTypeRequest<String> fromString() {
        return loadGeneric(String.class);
}

流程图如下:
RequestManager.load

  1. buildModelLoader: 根据请求的model和需要解析的model获取到对应的ModelLoader

  • Glide.buildModelLoader()

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

    public static <T, Y> ModelLoader<T, Y> buildModelLoader(Class<T> modelClass, Class<Y> resourceClass,
               Context context) {
            if (modelClass == null) {
               if (Log.isLoggable(TAG, Log.DEBUG)) {
                   Log.d(TAG, "Unable to load null model, setting placeholder only");
               }
               return null;
           }
          //详见【1.1】 Glide.get  详见【1.2】 buildModelLoader
           return Glide.get(context).getLoaderFactory().buildModelLoader(modelClass, resourceClass);
       }

  • 1.1

    • Glide.get()：module配置解析，初始化Glide对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public static Glide get(Context context) {
        if (glide == null) {
            synchronized (Glide.class) {
                if (glide == null) {
                    Context applicationContext = context.getApplicationContext();
                    //解析Manifest配置的GlideModule  详见【1.1.1】
                    List<GlideModule> modules = new ManifestParser(applicationContext).parse();

                    GlideBuilder builder = new GlideBuilder(applicationContext);
                    //遍历module，完成赋值 
                    for (GlideModule module : modules) {
                        module.applyOptions(applicationContext, builder);
                    }
                    //初始化Glide 详见【1.1.2】
                    glide = builder.createGlide();
                     //遍历module，完成注册
                    for (GlideModule module : modules) {
                        module.registerComponents(applicationContext, glide);
                    }
                }
            }
        }

        return glide;
    }

  • 1.1.1

    • ManifestParser.parser()：解析AndroidManifest.xml配置的module
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      public List<GlideModule> parse() {
              List<GlideModule> modules = new ArrayList<GlideModule>();
              try {
                  ApplicationInfo appInfo = context.getPackageManager().getApplicationInfo(
                          context.getPackageName(), PackageManager.GET_META_DATA);
                  if (appInfo.metaData != null) {
                      for (String key : appInfo.metaData.keySet()) {
                          if (GLIDE_MODULE_VALUE.equals(appInfo.metaData.get(key))) {
                              modules.add(parseModule(key));
                          }
                      }
                  }
              } catch (PackageManager.NameNotFoundException e) {
                  throw new RuntimeException("Unable to find metadata to parse GlideModules", e);
              }

              return modules;
          }

          private static GlideModule parseModule(String className) {
              Class<?> clazz;
              try {
                  clazz = Class.forName(className);
              } catch (ClassNotFoundException e) {
                  throw new IllegalArgumentException("Unable to find GlideModule implementation", e);
              }

              Object module;
              try {
                  //初始化module
                  module = clazz.newInstance();
              } catch (InstantiationException e) {
                  throw new RuntimeException("Unable to instantiate GlideModule implementation for " + clazz, e);
              } catch (IllegalAccessException e) {
                  throw new RuntimeException("Unable to instantiate GlideModule implementation for " + clazz, e);
              }

              if (!(module instanceof GlideModule)) {
                  throw new RuntimeException("Expected instanceof GlideModule, but found: " + module);
              }
              return (GlideModule) module;
          }

  • 1.1.2

    • GlideBuilder.createGlide():Glide初始化
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
      100
      101
      102
      103
      104
      105
      106
      107
      108
      109
      110
      111
      112
      113
      114
      115
      116
      117
      118
      Glide createGlide() {
              if (sourceService == null) {
                  //根据cpu获取核心加载数量
                  final int cores = Math.max(1, Runtime.getRuntime().availableProcessors());
                  //具有优先级顺序的线程池
                  sourceService = new FifoPriorityThreadPoolExecutor(cores);
              }
              if (diskCacheService == null) {
                  diskCacheService = new FifoPriorityThreadPoolExecutor(1);
              }
              //缓存计算类
              MemorySizeCalculator calculator = new MemorySizeCalculator(context);
              if (bitmapPool == null) {
                  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
                      int size = calculator.getBitmapPoolSize();
                      //位图池
                      bitmapPool = new LruBitmapPool(size);
                  } else {
                      bitmapPool = new BitmapPoolAdapter();
                  }
              }
              
              //内存缓存
              if (memoryCache == null) {
                  memoryCache = new LruResourceCache(calculator.getMemoryCacheSize());
              }
              
              //磁盘缓存
              if (diskCacheFactory == null) {
                  diskCacheFactory = new InternalCacheDiskCacheFactory(context);
              }

              //负责启动request load和管理内存的引擎类
              if (engine == null) {
                  engine = new Engine(memoryCache, diskCacheFactory, diskCacheService, sourceService);
              }

              if (decodeFormat == null) {
                  //编码格式  默认PREFER_RGB_565
                  decodeFormat = DecodeFormat.DEFAULT;
              }

              return new Glide(engine, memoryCache, bitmapPool, context, decodeFormat);
      }

      Glide(Engine engine, MemoryCache memoryCache, BitmapPool bitmapPool, Context context, DecodeFormat decodeFormat) {
              this.engine = engine;
              this.bitmapPool = bitmapPool;
              this.memoryCache = memoryCache;
              this.decodeFormat = decodeFormat;
              //ModelLoader生成工厂类
              loaderFactory = new GenericLoaderFactory(context);
              mainHandler = new Handler(Looper.getMainLooper());
             
              bitmapPreFiller = new BitmapPreFiller(memoryCache, bitmapPool, decodeFormat);


              //DataLoadProviderRegistry 注册
              dataLoadProviderRegistry = new DataLoadProviderRegistry();

              StreamBitmapDataLoadProvider streamBitmapLoadProvider =
                      new StreamBitmapDataLoadProvider(bitmapPool, decodeFormat);
              dataLoadProviderRegistry.register(InputStream.class, Bitmap.class, streamBitmapLoadProvider);

              FileDescriptorBitmapDataLoadProvider fileDescriptorLoadProvider =
                      new FileDescriptorBitmapDataLoadProvider(bitmapPool, decodeFormat);
              dataLoadProviderRegistry.register(ParcelFileDescriptor.class, Bitmap.class, fileDescriptorLoadProvider);

              ImageVideoDataLoadProvider imageVideoDataLoadProvider =
                      new ImageVideoDataLoadProvider(streamBitmapLoadProvider, fileDescriptorLoadProvider);
              dataLoadProviderRegistry.register(ImageVideoWrapper.class, Bitmap.class, imageVideoDataLoadProvider);

              GifDrawableLoadProvider gifDrawableLoadProvider =
                      new GifDrawableLoadProvider(context, bitmapPool);
              dataLoadProviderRegistry.register(InputStream.class, GifDrawable.class, gifDrawableLoadProvider);

              dataLoadProviderRegistry.register(ImageVideoWrapper.class, GifBitmapWrapper.class,
                      new ImageVideoGifDrawableLoadProvider(imageVideoDataLoadProvider, gifDrawableLoadProvider, bitmapPool));

              dataLoadProviderRegistry.register(InputStream.class, File.class, new StreamFileDataLoadProvider());

              //GenericLoaderFactory注册 
              register(File.class, ParcelFileDescriptor.class, new FileDescriptorFileLoader.Factory());
              register(File.class, InputStream.class, new StreamFileLoader.Factory());
              register(int.class, ParcelFileDescriptor.class, new FileDescriptorResourceLoader.Factory());
              register(int.class, InputStream.class, new StreamResourceLoader.Factory());
              register(Integer.class, ParcelFileDescriptor.class, new FileDescriptorResourceLoader.Factory());
              register(Integer.class, InputStream.class, new StreamResourceLoader.Factory());
              register(String.class, ParcelFileDescriptor.class, new FileDescriptorStringLoader.Factory());
              register(String.class, InputStream.class, new StreamStringLoader.Factory());
              register(Uri.class, ParcelFileDescriptor.class, new FileDescriptorUriLoader.Factory());
              register(Uri.class, InputStream.class, new StreamUriLoader.Factory());
              register(URL.class, InputStream.class, new StreamUrlLoader.Factory());
              register(GlideUrl.class, InputStream.class, new HttpUrlGlideUrlLoader.Factory());
              register(byte[].class, InputStream.class, new StreamByteArrayLoader.Factory());

              //TranscoderRegistry 注册
              transcoderRegistry.register(Bitmap.class, GlideBitmapDrawable.class,
                      new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool));
              transcoderRegistry.register(GifBitmapWrapper.class, GlideDrawable.class,
                      new GifBitmapWrapperDrawableTranscoder(
                              new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool)));

              bitmapCenterCrop = new CenterCrop(bitmapPool);
              drawableCenterCrop = new GifBitmapWrapperTransformation(bitmapPool, bitmapCenterCrop);

              bitmapFitCenter = new FitCenter(bitmapPool);
              drawableFitCenter = new GifBitmapWrapperTransformation(bitmapPool, bitmapFitCenter);
      }

      //根据modelClass，resourceClass，ModelLoaderFactory注册到GenericLoaderFactory
      public <T, Y> void register(Class<T> modelClass, Class<Y> resourceClass, ModelLoaderFactory<T, Y> factory) {
              //详见【1.1.3】
              ModelLoaderFactory<T, Y> removed = loaderFactory.register(modelClass, resourceClass, factory);
              if (removed != null) {
                  removed.teardown();
              }
      }

可以看到，Glide初始化的时候做了很多的事，初始化了缓存相关的类，任务执行以及缓存管理的引擎，注册了DataLoadProviderRegistry GenericLoaderFactory等等这些。这个时候我们知道了Glide.buildModelLoader()函数里面Glide.get(context).getLoaderFactory()对象为GenericLoaderFactory

  • 1.1.3

    • GenericLoaderFactory.register()
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      public synchronized <T, Y> ModelLoaderFactory<T, Y> register(Class<T> modelClass, Class<Y> resourceClass,
                  ModelLoaderFactory<T, Y> factory) {
              cachedModelLoaders.clear();

              //modelClassToResourceFactories key为modelClass,值为已resourceClass为key，factory为值得HashMap
              
              //根据modelClass获取resourceToFactories
              Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> resourceToFactories = modelClassToResourceFactories.get(modelClass);
              if (resourceToFactories == null) {
                  resourceToFactories = new HashMap<Class/*Y*/, ModelLoaderFactory/*T, Y*/>();
                  modelClassToResourceFactories.put(modelClass, resourceToFactories);
              }
              
              ModelLoaderFactory/*T, Y*/ previous = resourceToFactories.put(resourceClass, factory);

              if (previous != null) {
                  // This factory may be being used by another model. We don't want to say it has been removed unless we
                  // know it has been removed for all models.
                  for (Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> factories : modelClassToResourceFactories.values()) {
                      if (factories.containsValue(previous)) {
                          previous = null;
                          break;
                      }
                  }
              }

              return previous;
          }

  • 1.2

    • GenericLoaderFactory.buildModelLoader()
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      public synchronized <T, Y> ModelLoader<T, Y> buildModelLoader(Class<T> modelClass, Class<Y> resourceClass) {
              //获取缓存的ModelLoader
              ModelLoader<T, Y> result = getCachedLoader(modelClass, resourceClass);
              if (result != null) {
                  // We've already tried to create a model loader and can't with the currently registered set of factories,
                  // but we can't use null to demonstrate that failure because model loaders that haven't been requested
                  // yet will be null in the cache. To avoid this, we use a special signal model loader.
                  if (NULL_MODEL_LOADER.equals(result)) {
                      return null;
                  } else {
                      return result;
                  }
              }
              //根据 modelClass 和 resourceClass获取对应的ModelLoaderFactory
              final ModelLoaderFactory<T, Y> factory = getFactory(modelClass, resourceClass);
              if (factory != null) {
                  //根据ModelLoaderFactory获取到ModelLoader，并将存到缓存，详见【1.2.1】
                  result = factory.build(context, this);
                  cacheModelLoader(modelClass, resourceClass, result);
              } else {
                  // We can't generate a model loader for the given arguments with the currently registered set of factories.
                  cacheNullLoader(modelClass, resourceClass);
              }
              return result;
          }
          
          
          private <T, Y> ModelLoaderFactory<T, Y> getFactory(Class<T> modelClass, Class<Y> resourceClass) {
              // 在【1.1.2】Glide初始化的时候modelClassToResourceFactories注册对应关系
              Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> resourceToFactories = modelClassToResourceFactories.get(modelClass);
              ModelLoaderFactory/*T, Y*/ result = null;
              if (resourceToFactories != null) {
                  result = resourceToFactories.get(resourceClass);
              }

              if (result == null) {
                  for (Class<? super T> registeredModelClass : modelClassToResourceFactories.keySet()) {
                      // This accounts for model subclasses, our map only works for exact matches. We should however still
                      // match a subclass of a model with a factory for a super class of that model if if there isn't a
                      // factory for that particular subclass. Uris are a great example of when this happens, most uris
                      // are actually subclasses for Uri, but we'd generally rather load them all with the same factory rather
                      // than trying to register for each subclass individually.
                      if (registeredModelClass.isAssignableFrom(modelClass)) {
                          Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> currentResourceToFactories =
                                  modelClassToResourceFactories.get(registeredModelClass);
                          if (currentResourceToFactories != null) {
                              result = currentResourceToFactories.get(resourceClass);
                              if (result != null) {
                                  break;
                              }
                          }
                      }
                  }
              }

              return result;
          }

  • 1.2.1

    • factory.build():根据ModelLoaderFactory获取到ModelLoader,这里用module.class=String.class来举例， 【1.1.2】Glide初始化的时候可知道register(String.class, InputStream.class, new StreamStringLoader.Factory());
    • StreamStringLoader.Factory.build()
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
      100
      101
      102
      public class StreamStringLoader extends StringLoader<InputStream> implements StreamModelLoader<String> {

          /**
           * The default factory for {@link com.bumptech.glide.load.model.stream.StreamStringLoader}s.
           */
          public static class Factory implements ModelLoaderFactory<String, InputStream> {
              @Override
              public ModelLoader<String, InputStream> build(Context context, GenericLoaderFactory factories) {
                  //这里通过`factories.buildModelLoader`来构建一个`module.class=Uri.class`类型的`ModuleLoader`，从【1.1.2】里面可以看到`register(Uri.class, InputStream.class, new StreamUriLoader.Factory());`。`factories.buildModelLoader`详见【1.2】 
                  return new StreamStringLoader(factories.buildModelLoader(Uri.class, InputStream.class));
              }

              @Override
              public void teardown() {
                  // Do nothing.
              }
          }

          public StreamStringLoader(Context context) {
              this(Glide.buildStreamModelLoader(Uri.class, context));
          }

          public StreamStringLoader(ModelLoader<Uri, InputStream> uriLoader) {
              super(uriLoader);
          }
      }


      public class StreamUriLoader extends UriLoader<InputStream> implements StreamModelLoader<Uri> {

          /**
           * THe default factory for {@link com.bumptech.glide.load.model.stream.StreamUriLoader}s.
           */
          public static class Factory implements ModelLoaderFactory<Uri, InputStream> {

              @Override
              public ModelLoader<Uri, InputStream> build(Context context, GenericLoaderFactory factories) {
              //【1.1.2】  register(GlideUrl.class, InputStream.class, new HttpUrlGlideUrlLoader.Factory());
                  return new StreamUriLoader(context, factories.buildModelLoader(GlideUrl.class, InputStream.class));
              }

              @Override
              public void teardown() {
                  // Do nothing.
              }
          }

          public StreamUriLoader(Context context) {
              this(context, Glide.buildStreamModelLoader(GlideUrl.class, context));
          }

          public StreamUriLoader(Context context, ModelLoader<GlideUrl, InputStream> urlLoader) {
              super(context, urlLoader);
          }

          //...
      }


      public class HttpUrlGlideUrlLoader implements ModelLoader<GlideUrl, InputStream> {

          private final ModelCache<GlideUrl, GlideUrl> modelCache;

          /**
           * The default factory for {@link com.bumptech.glide.load.model.stream.HttpUrlGlideUrlLoader}s.
           */
          public static class Factory implements ModelLoaderFactory<GlideUrl, InputStream> {
              private final ModelCache<GlideUrl, GlideUrl> modelCache = new ModelCache<GlideUrl, GlideUrl>(500);

              @Override
              public ModelLoader<GlideUrl, InputStream> build(Context context, GenericLoaderFactory factories) {
                  return new HttpUrlGlideUrlLoader(modelCache);
              }

              @Override
              public void teardown() {
                  // Do nothing.
              }
          }

          public HttpUrlGlideUrlLoader() {
              this(null);
          }

          public HttpUrlGlideUrlLoader(ModelCache<GlideUrl, GlideUrl> modelCache) {
              this.modelCache = modelCache;
          }

          @Override
          public DataFetcher<InputStream> getResourceFetcher(GlideUrl model, int width, int height) {
              // GlideUrls memoize parsed URLs so caching them saves a few object instantiations and time spent parsing urls.
              GlideUrl url = model;
              if (modelCache != null) {
                  url = modelCache.get(model, 0, 0);
                  if (url == null) {
                      modelCache.put(model, 0, 0, model);
                      url = model;
                  }
              }
              return new HttpUrlFetcher(url);
          }
      }

StreamStringLoader继承StringLoader,StringLoader里面有一个ModelLoader uriLoader成员变量,当build的时候，这里通过factories.buildModelLoader来构建一个module.class=Uri.class类型的ModuleLoader，从【1.1.2】里面可以看到register(Uri.class, InputStream.class, new StreamUriLoader.Factory());`StreamUriLoader继承UriLoader，它有一个ModelLoader urlLoader成员变量，这个时候也通过factories.buildModelLoader以module.class = GlideUrl.class的方式获取,【1.1.2】register(GlideUrl.class, InputStream.class, new HttpUrlGlideUrlLoader.Factory());`，这里一层一层的获取很是巧妙。

  1. Glide.buildFileDescriptorModelLoader：获取fileDescriptorModelLoader
    1
    2
    3
    4
    5
    public static <T> ModelLoader<T, ParcelFileDescriptor> buildFileDescriptorModelLoader(Class<T> modelClass,
             Context context) {
             //详见【1】
         return buildModelLoader(modelClass, ParcelFileDescriptor.class, context);
     }

这一步和【1】差不多的流程，已module.class = String.class为例子，register(String.class, ParcelFileDescriptor.class, new FileDescriptorStringLoader.Factory());于【1.2.1】类似，也是一层一层的获取，这就不废话了。

  1. 获取DrawableTypeRequest: DrawableTypeRequest继承DrawableRequestBuilder,DrawableRequestBuilder继承GenericRequestBuilder
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    private final OptionsApplier optionsApplier;
    this.optionsApplier = new OptionsApplier();

    //【3.1】  new DrawableTypeRequest
    optionsApplier.apply(
                    new DrawableTypeRequest<T>(modelClass, streamModelLoader, fileDescriptorModelLoader, context,
                            glide, requestTracker, lifecycle, optionsApplier))
                            
    class OptionsApplier {
            public <A, X extends GenericRequestBuilder<A, ?, ?, ?>> X apply(X builder) {
            //HOOK 
                if (options != null) {
                    options.apply(builder);
                }
                return builder;
            }
        }

这里获取Request对象的时候，留了一个hook。

  • 3.1

    • new DrawableTypeRequest
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      DrawableTypeRequest(Class<ModelType> modelClass, ModelLoader<ModelType, InputStream> streamModelLoader,
                  ModelLoader<ModelType, ParcelFileDescriptor> fileDescriptorModelLoader, Context context, Glide glide,
                  RequestTracker requestTracker, Lifecycle lifecycle, RequestManager.OptionsApplier optionsApplier) {
                  //【3.2】 buildProvider
              super(context, modelClass,
                      buildProvider(glide, streamModelLoader, fileDescriptorModelLoader, GifBitmapWrapper.class,
                              GlideDrawable.class, null),
                      glide, requestTracker, lifecycle);
              this.streamModelLoader = streamModelLoader;
              this.fileDescriptorModelLoader = fileDescriptorModelLoader;
              this.optionsApplier = optionsApplier;
          }
          
          
          DrawableRequestBuilder(Context context, Class<ModelType> modelClass,
                  LoadProvider<ModelType, ImageVideoWrapper, GifBitmapWrapper, GlideDrawable> loadProvider, Glide glide,
                  RequestTracker requestTracker, Lifecycle lifecycle) {
              super(context, modelClass, loadProvider, GlideDrawable.class, glide, requestTracker, lifecycle);
              // Default to animating.
              crossFade();
          }
          
          
          GenericRequestBuilder(Context context, Class<ModelType> modelClass,
                  LoadProvider<ModelType, DataType, ResourceType, TranscodeType> loadProvider,
                  Class<TranscodeType> transcodeClass, Glide glide, RequestTracker requestTracker, Lifecycle lifecycle) {
              this.context = context;
              this.modelClass = modelClass;
              this.transcodeClass = transcodeClass;
              this.glide = glide;
              this.requestTracker = requestTracker;
              this.lifecycle = lifecycle;
              this.loadProvider = loadProvider != null
                      ? new ChildLoadProvider<ModelType, DataType, ResourceType, TranscodeType>(loadProvider) : null;

              if (context == null) {
                  throw new NullPointerException("Context can't be null");
              }
              if (modelClass != null && loadProvider == null) {
                  throw new NullPointerException("LoadProvider must not be null");
              }
          }

  • 3.2

    • buildProvider
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      private static <A, Z, R> FixedLoadProvider<A, ImageVideoWrapper, Z, R> buildProvider(Glide glide,
                 ModelLoader<A, InputStream> streamModelLoader,
                 ModelLoader<A, ParcelFileDescriptor> fileDescriptorModelLoader, Class<Z> resourceClass,
                 Class<R> transcodedClass,
                 ResourceTranscoder<Z, R> transcoder) {
             if (streamModelLoader == null && fileDescriptorModelLoader == null) {
                 return null;
             }

             if (transcoder == null) {
             //获取ResourceTranscoder详见【3.2.1】  --> GifBitmapWrapperDrawableTranscoder
                 transcoder = glide.buildTranscoder(resourceClass, transcodedClass);
             }
             //详见【3.2.2】
             DataLoadProvider<ImageVideoWrapper, Z> dataLoadProvider = glide.buildDataProvider(ImageVideoWrapper.class,
                     resourceClass);
             ImageVideoModelLoader<A> modelLoader = new ImageVideoModelLoader<A>(streamModelLoader,
                     fileDescriptorModelLoader);
             return new FixedLoadProvider<A, ImageVideoWrapper, Z, R>(modelLoader, transcoder, dataLoadProvider);
         }

这里resourceClass = GifBitmapWrapper.class,transcodedClass = GlideDrawable.class

  • 3.2.1
    • glide.buildTranscoder
      1
      2
      3
      <Z, R> ResourceTranscoder<Z, R> buildTranscoder(Class<Z> decodedClass, Class<R> transcodedClass) {
             return transcoderRegistry.get(decodedClass, transcodedClass);
         }

从【1.1.2】

1
2
3
transcoderRegistry.register(GifBitmapWrapper.class, GlideDrawable.class,
               new GifBitmapWrapperDrawableTranscoder(
                       new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool)));

获取的transcoder为GifBitmapWrapperDrawableTranscoder

  • 3.2.2
    • glide.buildDataProvider
      1
      2
      3
      <T, Z> DataLoadProvider<T, Z> buildDataProvider(Class<T> dataClass, Class<Z> decodedClass) {
             return dataLoadProviderRegistry.get(dataClass, decodedClass);
         }

这里dataClass = ImageVideoWrapper.class,decodedClass = resourceClass = GifBitmapWrapper.class
从【1.1.2】

1
2
dataLoadProviderRegistry.register(ImageVideoWrapper.class, GifBitmapWrapper.class,
               new ImageVideoGifDrawableLoadProvider(imageVideoDataLoadProvider, gifDrawableLoadProvider, bitmapPool));

获取的DataLoadProvider为ImageVideoGifDrawableLoadProvider

  1. DrawableTypeRequest.load
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

     @Override
        public DrawableRequestBuilder<ModelType> load(ModelType model) {
            super.load(model);
            return this;
        }
        

    public GenericRequestBuilder<ModelType, DataType, ResourceType, TranscodeType> load(ModelType model) {
            this.model = model;
            isModelSet = true;
            return this;
        }

最后的load就是设置一些moduleType。

总结：

  1. Glide.with获取到RequestManager对象，然后我们通过RequestManager.load根据modelType获取到GenericRequestBuilder对象。
  2. Glide根据modelType生成Request采用了工厂，并且初始化ModuleLoader的时候，里面又包含着另外一个ModuleLoader引用，很是巧妙。具体查看【1.2】
  3. 一个modelType(modelClass)对应多个resourceType(resourceClass),一个resourceType对应一个transcodedType(transcodedClass)
  4. modelType可以理解为请求的类型,String Uri File等;resourceType可以理解为请求的结果形式，比如Stream File等；transcodedType可以理解为图片的转换类型Drawable Bitmap等。
-------------The End-------------